home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / iterator.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  28.5 KB  |  913 lines
  1. #ifndef __STD_ITERATOR__
  2. #define __STD_ITERATOR__
  3. #pragma option push -b -a4 -Vx- -Ve- -w-inl -w-aus -w-sig
  4.  
  5. /***************************************************************************
  6.  *
  7.  * iterator - iterator declarations for the Standard Library
  8.  *
  9.  * $Id: iterator,v 1.70 1996/09/27 08:02:52 smithey Exp $
  10.  *
  11.  ***************************************************************************
  12.  *
  13.  * Copyright (c) 1994
  14.  * Hewlett-Packard Company
  15.  *
  16.  * Permission to use, copy, modify, distribute and sell this software
  17.  * and its documentation for any purpose is hereby granted without fee,
  18.  * provided that the above copyright notice appear in all copies and
  19.  * that both that copyright notice and this permission notice appear
  20.  * in supporting documentation.  Hewlett-Packard Company makes no
  21.  * representations about the suitability of this software for any
  22.  * purpose.  It is provided "as is" without express or implied warranty.
  23.  *
  24.  *
  25.  ***************************************************************************
  26.  *
  27.  * (c) Copyright 1994, 1995 Rogue Wave Software, Inc.
  28.  * ALL RIGHTS RESERVED *
  29.  * The software and information contained herein are proprietary to, and
  30.  * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
  31.  * intends to preserve as trade secrets such software and information.
  32.  * This software is furnished pursuant to a written license agreement and
  33.  * may be used, copied, transmitted, and stored only in accordance with
  34.  * the terms of such license and with the inclusion of the above copyright
  35.  * notice.  This software and information or any other copies thereof may
  36.  * not be provided or otherwise made available to any other person.
  37.  *
  38.  * Notwithstanding any other lease or license that may pertain to, or
  39.  * accompany the delivery of, this computer software and information, the
  40.  * rights of the Government regarding its use, reproduction and disclosure
  41.  * are as set forth in Section 52.227-19 of the FARS Computer
  42.  * Software-Restricted Rights clause.
  43.  * 
  44.  * Use, duplication, or disclosure by the Government is subject to
  45.  * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  46.  * Technical Data and Computer Software clause at DFARS 252.227-7013.
  47.  * Contractor/Manufacturer is Rogue Wave Software, Inc.,
  48.  * P.O. Box 2328, Corvallis, Oregon 97339.
  49.  *
  50.  * This computer software and information is distributed with "restricted
  51.  * rights."  Use, duplication or disclosure is subject to restrictions as
  52.  * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
  53.  * Computer Software-Restricted Rights (April 1985)."  If the Clause at
  54.  * 18-52.227-74 "Rights in Data General" is specified in the contract,
  55.  * then the "Alternate III" clause applies.
  56.  *
  57.  **************************************************************************/
  58.  
  59. #include <stdcomp.h>
  60. #include <rw/stddefs.h>
  61.  
  62. #ifndef _RWSTD_NO_NEW_HEADER
  63. #include <cstddef>
  64. #else
  65. #include <stddef.h>
  66. #endif
  67.  
  68. #ifdef _RWSTD_NO_BASE_CLASS_MATCH
  69. #define _RWSTD_VALUE_TYPE(a) value_type(*(a))
  70. #else
  71. #define _RWSTD_VALUE_TYPE(a) value_type(a)
  72. #endif
  73.  
  74. #ifndef _RWSTD_NO_NAMESPACE
  75. namespace std {
  76. #endif
  77.  
  78. //
  79. // Standard iterator tags.
  80. //
  81.   
  82. struct input_iterator_tag
  83. {
  84.     input_iterator_tag() {;}
  85. };
  86.  
  87. struct output_iterator_tag
  88. {
  89.     output_iterator_tag() {;}
  90. };
  91.  
  92. struct forward_iterator_tag : public input_iterator_tag
  93. {
  94.     forward_iterator_tag() {;}
  95. };
  96.  
  97. struct bidirectional_iterator_tag : public forward_iterator_tag
  98. {
  99.     bidirectional_iterator_tag() {;}
  100. };
  101.  
  102. struct random_access_iterator_tag : public bidirectional_iterator_tag
  103. {
  104.     random_access_iterator_tag() {;}
  105. };
  106.  
  107.  
  108. //
  109. // Basic iterators.
  110. //
  111.  
  112. //
  113. // Note that _RWSTD_SIMPLE_DEFAULT(x)
  114. // will expand to: ' = x', or nothing,
  115. // depending on your compiler's capabilities and/or
  116. // flag settings (see stdcomp.h).
  117. //
  118. template <class Category, class T,  
  119.           class Distance _RWSTD_SIMPLE_DEFAULT(ptrdiff_t)>
  120. struct iterator
  121. {
  122.    typedef T value_type;
  123.    typedef Distance distance_type;
  124.    typedef Category iterator_category;
  125. };
  126.  
  127. #ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
  128.  
  129. template <class Iterator> struct iterator_traits
  130. {
  131.    typedef _TYPENAME Iterator::value_type value_type;
  132.    typedef _TYPENAME Iterator::distance_type distance_type;
  133.    typedef _TYPENAME Iterator::iterator_category iterator_category;
  134. };
  135. template <class T> struct iterator_traits<T*>
  136. {
  137.    typedef T value_type;
  138.    typedef ptrdiff_t distance_type;
  139.    typedef random_access_iterator_tag iterator_category;
  140. };
  141.  
  142. template <class ForwardIterator>
  143. inline iterator_traits<ForwardIterator>::distance_type
  144. distance (ForwardIterator first, ForwardIterator last)
  145. {
  146.     iterator_traits<ForwardIterator>::distance_type n = 0;
  147.     __distance(first, last, n, 
  148.                iterator_traits<ForwardIterator>::iterator_category);
  149.     return n;
  150. }
  151.  
  152. template <class ForwardIterator, class Distance>
  153. inline void advance (ForwardIterator& i, Distance n)
  154. {
  155.     __advance(i, n, iterator_traits<ForwardIterator>::iterator_category);
  156. }
  157.  
  158. #endif /* _RWSTD_NO_CLASS_PARTIAL_SPEC */
  159.  
  160.  
  161.  
  162. template <class T > 
  163. struct input_iterator : public iterator<input_iterator_tag,T,ptrdiff_t>
  164. {
  165. #ifdef _RWSTD_NO_BASE_CLASS_MATCH
  166.     T* operator* () { return _RWSTD_STATIC_CAST(T*,0); } 
  167. #endif
  168. };
  169.  
  170. struct output_iterator : public iterator<output_iterator_tag,void,void>
  171. {
  172.     typedef output_iterator_tag iterator_category;
  173. };
  174.  
  175. template <class T, class Distance _RWSTD_SIMPLE_DEFAULT(ptrdiff_t) > 
  176. struct forward_iterator : public iterator<forward_iterator_tag,T,Distance>
  177. {
  178. #ifdef _RWSTD_NO_BASE_CLASS_MATCH
  179.     T* operator* () { return _RWSTD_STATIC_CAST(T*,0); } 
  180. #endif
  181. };
  182.  
  183. template <class T, class Distance _RWSTD_SIMPLE_DEFAULT(ptrdiff_t)> 
  184. struct bidirectional_iterator : public iterator<bidirectional_iterator_tag,T,Distance>
  185. {
  186. #ifdef _RWSTD_NO_BASE_CLASS_MATCH
  187.     T* operator* () { return _RWSTD_STATIC_CAST(T*,0); } 
  188. #endif
  189. };
  190.  
  191. template <class T, class Distance _RWSTD_SIMPLE_DEFAULT(ptrdiff_t)> 
  192. struct random_access_iterator : public iterator<random_access_iterator_tag,T,Distance>
  193. {
  194. #ifdef _RWSTD_NO_BASE_CLASS_MATCH
  195.     T* operator* () { return _RWSTD_STATIC_CAST(T*,0); } 
  196. #endif
  197. };
  198.  
  199.  
  200. //
  201. // Iterator category.
  202. //
  203.  
  204. template <class T>
  205. inline input_iterator_tag 
  206. iterator_category (const input_iterator<T>&)
  207. {
  208.     return input_iterator_tag();
  209. }
  210.  
  211. inline output_iterator_tag iterator_category (const output_iterator&)
  212. {
  213.     return output_iterator_tag();
  214. }
  215.  
  216. template <class T, class Distance> 
  217. inline forward_iterator_tag
  218. iterator_category (const forward_iterator<T, Distance>&)
  219. {
  220.     return forward_iterator_tag();
  221. }
  222.  
  223. template <class T, class Distance>
  224. inline bidirectional_iterator_tag
  225. iterator_category (const bidirectional_iterator<T, Distance>&)
  226. {
  227.     return bidirectional_iterator_tag();
  228. }
  229.  
  230. template <class T, class Distance> 
  231. inline random_access_iterator_tag
  232. iterator_category (const random_access_iterator<T, Distance>&)
  233. {
  234.     return random_access_iterator_tag();
  235. }
  236.  
  237.  
  238. template <class T>
  239. inline random_access_iterator_tag iterator_category (const T*)
  240. {
  241.     return random_access_iterator_tag();
  242. }
  243.  
  244. //
  245. // Value type.
  246. //
  247.  
  248. #ifndef _RWSTD_NO_BASE_CLASS_MATCH
  249. template <class T> 
  250. inline T* value_type (const input_iterator<T>&)
  251. {
  252.   return _RWSTD_STATIC_CAST(T*,0);
  253. }
  254.  
  255. template <class T, class Distance> 
  256. inline T* value_type (const forward_iterator<T, Distance>&)
  257. {
  258.   return _RWSTD_STATIC_CAST(T*,0);
  259. }
  260.  
  261. template <class T, class Distance> 
  262. inline T* value_type (const bidirectional_iterator<T, Distance>&)
  263. {
  264.   return _RWSTD_STATIC_CAST(T*,0);
  265. }
  266.  
  267. template <class T, class Distance> 
  268. inline T* value_type (const random_access_iterator<T, Distance>&)
  269. {
  270.   return _RWSTD_STATIC_CAST(T*,0);
  271. }
  272.  
  273. template <class T>
  274. inline T* value_type (const T*)
  275. {
  276.   return _RWSTD_STATIC_CAST(T*,0);
  277. }
  278. #else
  279. template <class T>
  280. inline T* value_type (const T) 
  281. {
  282.   return _RWSTD_STATIC_CAST(T*,0);
  283. }
  284. #endif
  285.  
  286. //
  287. // Distance type.
  288. //
  289.  
  290. #ifndef _RWSTD_NO_BASE_CLASS_MATCH
  291. template <class T, class Distance> 
  292. inline Distance* distance_type (const forward_iterator<T, Distance>&)
  293. {
  294.   return _RWSTD_STATIC_CAST(Distance*,0);
  295. }
  296.  
  297. template <class T, class Distance> 
  298. inline Distance* 
  299. distance_type (const bidirectional_iterator<T, Distance>&)
  300. {
  301.   return _RWSTD_STATIC_CAST(Distance*,0);
  302. }
  303.  
  304. template <class T, class Distance>
  305. inline Distance* 
  306. distance_type (const random_access_iterator<T, Distance>&)
  307. {
  308.   return _RWSTD_STATIC_CAST(Distance*,0);
  309. }
  310.  
  311. template <class T>
  312. inline ptrdiff_t* distance_type (const T*)
  313. { 
  314.   return _RWSTD_STATIC_CAST(ptrdiff_t*,0);
  315. }
  316. #else
  317. template <class T>
  318. inline ptrdiff_t* distance_type (const T)  
  319. { 
  320.   return _RWSTD_STATIC_CAST(ptrdiff_t*,0);
  321. }
  322. #endif
  323.  
  324. //
  325. // Iterator operations.
  326. //
  327.  
  328. template <class InputIterator, class Distance>
  329. void __advance (InputIterator& i, Distance n, input_iterator_tag);
  330.  
  331. template <class ForwardIterator, class Distance>
  332. void __advance (ForwardIterator& i, Distance n, forward_iterator_tag);
  333.  
  334. template <class BidirectionalIterator, class Distance>
  335. void __advance (BidirectionalIterator& i, Distance n, 
  336.                 bidirectional_iterator_tag);
  337.  
  338. template <class InputIterator, class Distance>
  339. void __distance (InputIterator first, InputIterator last, Distance& n, 
  340.                  input_iterator_tag);
  341.  
  342. template <class ForwardIterator, class Distance>
  343. void __distance (ForwardIterator first, ForwardIterator last, Distance& n, 
  344.                  forward_iterator_tag);
  345.  
  346. template <class BidirectionalIterator, class Distance>
  347. void __distance (BidirectionalIterator first, BidirectionalIterator last, 
  348.                  Distance& n, bidirectional_iterator_tag);
  349.  
  350. template <class RandomAccessIterator, class Distance>
  351. inline void __distance (RandomAccessIterator first, RandomAccessIterator last, 
  352.                         Distance& n, random_access_iterator_tag)
  353. {
  354.     n = last - first;
  355. }
  356.  
  357. #ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
  358. template <class ForwardIterator, class Distance>
  359. inline void distance (ForwardIterator first, ForwardIterator last, Distance& n)
  360. {
  361. #ifndef _RWSTD_NO_BASE_CLASS_MATCH
  362.     __distance(first, last, n, iterator_category(first));
  363. #else
  364.     __distance(first, last, n, input_iterator_tag());
  365. #endif
  366. }
  367. #endif /* _RWSTD_NO_CLASS_PARTIAL_SPEC */
  368.  
  369.  
  370. template <class RandomAccessIterator, class Distance>
  371. inline void __advance (RandomAccessIterator& i, Distance n, 
  372.                        random_access_iterator_tag)
  373. {
  374.     i += n;
  375. }
  376.  
  377.  
  378. #ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
  379. template <class ForwardIterator, class Distance>
  380. inline void advance (ForwardIterator& i, Distance n)
  381. {
  382. #ifndef _RWSTD_NO_BASE_CLASS_MATCH
  383.     __advance(i, n, iterator_category(i));
  384. #else
  385.     __advance(i, n, input_iterator_tag());
  386. #endif
  387. }
  388. #endif /* _RWSTD_NO_CLASS_PARTIAL_SPEC */
  389.  
  390. //
  391. // Reverse bidirectional iterator.
  392. //
  393.  
  394.     //
  395.     // Forward declarations.
  396.     //
  397.  
  398. #ifdef _RWSTD_NO_UNDEFINED_FRIEND
  399. template <class BidirectionalIterator, class T, class Reference,
  400.           class Pointer, class Distance> class reverse_bidirectional_iterator;
  401.  
  402. template <class BidirectionalIterator, class T, class Reference,
  403.           class Pointer, class Distance>
  404. inline bool operator== (
  405.       const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  406.                                            Pointer, Distance>& x, 
  407.       const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  408.                                            Pointer, Distance>& y);
  409. #endif
  410.  
  411. #ifndef _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES
  412. #ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
  413. template <class BidirectionalIterator, 
  414.           class T = iterator_traits<BidirectionalIterator>::value_type, 
  415.           class Reference = T&,
  416.           class Pointer = T*, class Distance = ptrdiff_t> 
  417. #else
  418. template <class BidirectionalIterator, class T, class Reference = T&,
  419.           class Pointer = T*, class Distance = ptrdiff_t>
  420. #endif /* _RWSTD_NO_CLASS_PARTIAL_SPEC */
  421. #else
  422. template <class BidirectionalIterator, class T, class Reference, 
  423.           class Pointer, class Distance> 
  424. #endif /* _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES */
  425.  
  426. //
  427. // Reference = T& 
  428. // Distance  = ptrdiff_t
  429. // Pointer   = T*
  430. //
  431. class reverse_bidirectional_iterator
  432.     : public bidirectional_iterator<T,Distance>
  433. {
  434.     typedef reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  435.                                            Pointer, Distance> self;
  436.     friend bool operator== (const self& x, const self& y);
  437.  
  438.   protected:
  439.  
  440.     BidirectionalIterator current;
  441.  
  442.   public:
  443.  
  444.     typedef BidirectionalIterator iter_type;
  445.     typedef T value_type;
  446.     typedef Reference reference_type;
  447.     typedef Pointer pointer_type;
  448.     typedef Distance distance_type;
  449.  
  450.     reverse_bidirectional_iterator() {}
  451.     _EXPLICIT reverse_bidirectional_iterator (BidirectionalIterator x)
  452.         : current(x) {}
  453.     BidirectionalIterator base() const { return current; }
  454.     Reference operator* () const
  455.     {
  456.         BidirectionalIterator tmp = current; return *--tmp;
  457.     }
  458.     #ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN
  459.     Pointer operator->() const { return &(operator*()); }
  460.     #endif
  461.  
  462.     self& operator++ ()    { --current; return *this;                 }
  463.     self  operator++ (int) { self tmp = *this; --current; return tmp; }
  464.     self& operator-- ()    { ++current; return *this;                 }
  465.     self  operator-- (int) { self tmp = *this; ++current; return tmp; }
  466. };
  467.  
  468. template <class BidirectionalIterator, class T, class Reference,
  469.           class Pointer, class Distance>
  470. inline bool operator== (
  471.     const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  472.                                          Pointer, Distance>& x, 
  473.     const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  474.                                          Pointer, Distance>& y)
  475. {
  476.     return x.current == y.current;
  477. }
  478.  
  479. #if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
  480. template <class BidirectionalIterator, class T, class Reference,
  481.           class Pointer, class Distance>
  482. inline bool operator!= (
  483.     const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  484.                                          Pointer, Distance>& x, 
  485.     const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  486.                                          Pointer, Distance>& y)
  487. {
  488.     return !(x == y);
  489. }
  490. #endif
  491.  
  492. //
  493. // Reverse iterator.                                 
  494. //
  495.  
  496.     //
  497.     // Forward Declarations.
  498.     //
  499. #ifdef _RWSTD_NO_UNDEFINED_FRIEND
  500. template <class RandomAccessIterator, class T, class Reference,
  501.           class Pointer, class Distance>  class reverse_iterator;
  502.  
  503. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  504. inline bool operator== (const reverse_iterator<RandomAccessIterator, T,
  505.                  Reference, Pointer, Distance>& x, 
  506.                  const reverse_iterator<RandomAccessIterator, T,
  507.                  Reference, Pointer, Distance>& y);
  508.  
  509. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  510. inline bool operator< (const reverse_iterator<RandomAccessIterator, T,
  511.                 Reference, Pointer, Distance>& x, 
  512.                 const reverse_iterator<RandomAccessIterator, T,
  513.                 Reference, Pointer, Distance>& y);
  514.  
  515. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  516. inline Distance operator- (const reverse_iterator<RandomAccessIterator, T,
  517.                     Reference, Pointer, Distance>& x, 
  518.                     const reverse_iterator<RandomAccessIterator, T,
  519.                     Reference, Pointer, Distance>& y);
  520.  
  521. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  522. inline reverse_iterator<RandomAccessIterator, T, Reference, Pointer, Distance> 
  523. operator+ (Distance n,
  524.       const reverse_iterator<RandomAccessIterator, T, Reference, Pointer, Distance>& x);
  525. #endif
  526.  
  527. #ifndef _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES
  528. #ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
  529. template <class RandomAccessIterator, 
  530.           class T = iterator_traits<RandomAccessIterator>::value_type, 
  531.           class Reference = T&,
  532.           class Pointer = T*, class Distance = ptrdiff_t> 
  533. #else
  534. template <class RandomAccessIterator, class T, class Reference = T&,
  535.           class Pointer = T*, class Distance = ptrdiff_t>
  536. #endif /* _RWSTD_NO_CLASS_PARTIAL_SPEC */
  537. #else
  538. template <class RandomAccessIterator, class T, class Reference,
  539.           class Pointer, class Distance> 
  540. #endif /* _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES */
  541.  
  542. //
  543. // Reference = T&
  544. // Distance  = ptrdiff_t
  545. // Pointer   = T*
  546. //
  547. class reverse_iterator : public random_access_iterator<T, Distance>
  548. {
  549.     typedef reverse_iterator<RandomAccessIterator,T,Reference,Pointer,Distance> self;
  550.  
  551.     friend bool operator==    (const self& x, const self& y);
  552.     friend bool operator<     (const self& x, const self& y);
  553.     friend Distance operator- (const self& x, const self& y);
  554.     friend self operator+     (Distance n, const self& x);
  555.     
  556.   protected:
  557.  
  558.     RandomAccessIterator current;
  559.  
  560.   public:
  561.  
  562.     typedef RandomAccessIterator iter_type;
  563.     typedef T value_type;
  564.     typedef Reference reference_type;
  565.     typedef Pointer pointer_type;
  566.     typedef Distance distance_type;
  567.  
  568.     reverse_iterator() {}
  569.     _EXPLICIT reverse_iterator (RandomAccessIterator x) : current(x) {}
  570.     RandomAccessIterator base () const { return current; }
  571.     Reference operator* () const 
  572.     { RandomAccessIterator tmp = current; return *--tmp; }
  573.     #ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN
  574.     Pointer operator->() const { return &(operator*()); }
  575.     #endif
  576.  
  577.     self& operator++ ()    { --current; return *this;                 }
  578.     self  operator++ (int) { self tmp = *this; --current; return tmp; }
  579.     self& operator-- ()    { ++current; return *this;                 }
  580.     self  operator-- (int) { self tmp = *this; ++current; return tmp; }
  581.  
  582.     self  operator+  (Distance n) const { self tmp(current - n); return tmp; }
  583.     self& operator+= (Distance n)       { current -= n; return *this;        }
  584.     self  operator-  (Distance n) const { self tmp(current + n); return tmp; }
  585.     self& operator-= (Distance n)       { current += n; return *this;        }
  586.  
  587.     Reference operator[] (Distance n) const { return *(*this + n); }
  588. };
  589.  
  590. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  591. inline bool operator== (const reverse_iterator<RandomAccessIterator, T,
  592.                         Reference, Pointer, Distance>& x, 
  593.                         const reverse_iterator<RandomAccessIterator, T,
  594.                         Reference, Pointer, Distance>& y)
  595. {
  596.     return x.current == y.current;
  597. }
  598.  
  599. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  600. inline bool operator< (const reverse_iterator<RandomAccessIterator, T,
  601.                        Reference, Pointer, Distance>& x,
  602.                        const reverse_iterator<RandomAccessIterator, T,
  603.                        Reference, Pointer, Distance>& y)
  604. {
  605.     return y.current < x.current;
  606. }
  607.  
  608. #if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
  609. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  610. inline bool operator!= (const reverse_iterator<RandomAccessIterator, T,
  611.                         Reference, Pointer, Distance>& x, 
  612.                         const reverse_iterator<RandomAccessIterator, T,
  613.                         Reference, Pointer, Distance>& y)
  614. {
  615.     return !(x == y);
  616. }
  617.  
  618. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  619. inline bool operator> (const reverse_iterator<RandomAccessIterator, T,
  620.                        Reference, Pointer, Distance>& x,
  621.                        const reverse_iterator<RandomAccessIterator, T,
  622.                        Reference, Pointer, Distance>& y)
  623. {
  624.     return y < x;
  625. }
  626.  
  627. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  628. inline bool operator<= (const reverse_iterator<RandomAccessIterator, T,
  629.                        Reference, Pointer, Distance>& x,
  630.                        const reverse_iterator<RandomAccessIterator, T,
  631.                        Reference, Pointer, Distance>& y)
  632. {
  633.     return !(y < x);
  634. }
  635.  
  636. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  637. inline bool operator>= (const reverse_iterator<RandomAccessIterator, T,
  638.                        Reference, Pointer, Distance>& x,
  639.                        const reverse_iterator<RandomAccessIterator, T,
  640.                        Reference, Pointer, Distance>& y)
  641. {
  642.     return !(x < y);
  643. }
  644. #endif
  645.  
  646. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  647. inline Distance operator- (const reverse_iterator<RandomAccessIterator, T,
  648.                            Reference, Pointer, Distance>& x, 
  649.                            const reverse_iterator<RandomAccessIterator, T,
  650.                            Reference, Pointer, Distance>& y)
  651. {
  652.     return y.current - x.current;
  653. }
  654.  
  655. template <class RandomAccessIterator, class T, class Reference, class Pointer, class Distance>
  656. inline reverse_iterator<RandomAccessIterator, T, Reference, Pointer, Distance> 
  657. operator+ (Distance n, const reverse_iterator<RandomAccessIterator, T,
  658.            Reference, Pointer, Distance>& x)
  659. {
  660.     return reverse_iterator<RandomAccessIterator, T, Reference, Pointer, Distance>
  661.     (x.current - n);
  662. }
  663.  
  664. //
  665. // Back insert iterator.
  666. //
  667.  
  668. template <class Container>
  669. class back_insert_iterator : public output_iterator 
  670. {
  671.   protected:
  672.  
  673.     Container& container;
  674.  
  675.   public:
  676.     typedef Container container_type;
  677.     typedef _TYPENAME Container::value_type value_type;
  678.  
  679.     _EXPLICIT back_insert_iterator (Container& x) : container(x) {}
  680.     back_insert_iterator<Container>&
  681.     operator= (const _TYPENAME Container::value_type& value)
  682.     {
  683.         container.push_back(value); return *this;
  684.     }
  685.     back_insert_iterator<Container>& operator*  ()    { return *this; }
  686.     back_insert_iterator<Container>& operator++ ()    { return *this; }
  687.     back_insert_iterator<Container> operator++ (int) { return *this; }
  688. };
  689.  
  690. template <class Container>
  691. inline back_insert_iterator<Container> back_inserter (Container& x)
  692. {
  693.     return back_insert_iterator<Container>(x);
  694. }
  695.  
  696. //
  697. // Front insert iterator.
  698. //
  699.  
  700. template <class Container>
  701. class front_insert_iterator : public output_iterator 
  702. {
  703.   protected:
  704.  
  705.     Container& container;
  706.  
  707.   public:
  708.     typedef Container container_type;
  709.     typedef _TYPENAME Container::value_type value_type;
  710.  
  711.     _EXPLICIT front_insert_iterator (Container& x) : container(x) {}
  712.     front_insert_iterator<Container>&
  713.     operator= (const _TYPENAME Container::value_type& value)
  714.     { 
  715.         container.push_front(value); return *this;
  716.     }
  717.     front_insert_iterator<Container>& operator*  ()    { return *this; }
  718.     front_insert_iterator<Container>& operator++ ()    { return *this; }
  719.     front_insert_iterator<Container> operator++ (int) { return *this; }
  720. };
  721.  
  722. template <class Container>
  723. inline front_insert_iterator<Container> front_inserter (Container& x)
  724. {
  725.     return front_insert_iterator<Container>(x);
  726. }
  727.  
  728. //
  729. // Insert iterator.
  730. //
  731.  
  732. template <class Container>
  733. class insert_iterator : public output_iterator 
  734. {
  735.   private:
  736.     _TYPENAME Container::iterator iter;
  737.  
  738.   protected:
  739.     Container&                   container;
  740.  
  741.   public:
  742.     typedef Container container_type;
  743.     typedef _TYPENAME Container::value_type value_type;
  744.  
  745.     insert_iterator (Container& x, _TYPENAME Container::iterator i)
  746.         : container(x), iter(i) {}
  747.     insert_iterator<Container>&
  748.     operator= (const _TYPENAME Container::value_type& value)
  749.     { 
  750.         iter = container.insert(iter, value); ++iter; return *this;
  751.     }
  752.     insert_iterator<Container>& operator*  ()    { return *this; }
  753.     insert_iterator<Container>& operator++ ()    { return *this; }
  754.     insert_iterator<Container>& operator++ (int) { return *this; }
  755. };
  756.  
  757. template <class Container, class Iterator>
  758. inline insert_iterator<Container> inserter (Container& x, Iterator i)
  759. {
  760.     _TYPENAME Container::iterator c(i);
  761.     insert_iterator<Container> tmp(x, c);
  762.     return tmp;
  763. }
  764.  
  765. template <class charT> struct _RWSTDExportTemplate char_traits;
  766. _RWSTD_TEMPLATE struct _RWSTDExport char_traits<char>;
  767. #ifndef _RWSTD_NO_WIDE_CHAR
  768. _RWSTD_TEMPLATE struct _RWSTDExport char_traits<wchar_t>;
  769. #endif
  770.  
  771. #ifndef _RW_STD_IOSTREAM
  772.  
  773. #ifndef _RWSTD_NO_NAMESPACE
  774. }
  775. #endif
  776.  
  777. #include <iostream.h>
  778.  
  779. #ifndef _RWSTD_NO_NAMESPACE
  780. namespace std {
  781. #endif
  782.  
  783. //
  784. // Stream iterators.
  785. //
  786.  
  787. #ifdef _RWSTD_NO_UNDEFINED_FRIEND
  788. template <class T, class charT, class traits, class Distance>
  789. class istream_iterator;
  790.  
  791. template <class T, class charT, class traits, class Distance>
  792. bool operator== (const istream_iterator<T, charT,traits,Distance>& x,
  793.                  const istream_iterator<T, charT,traits,Distance>& y);
  794. #endif
  795.  
  796. #ifndef _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES
  797. template <class T, class charT, 
  798.           class traits = char_traits<charT>, 
  799.           class Distance = ptrdiff_t> 
  800. #else
  801. template <class T, class charT, class traits, class Distance>
  802. #endif
  803. class istream_iterator : public iterator<input_iterator_tag,T,void>
  804. {
  805.   friend bool operator== (const istream_iterator<T, charT,traits,Distance>& x,
  806.                           const istream_iterator<T, charT,traits,Distance>& y);
  807. protected:
  808.  
  809.     istream* stream;
  810.     T        value;
  811.     bool     end_marker;
  812.  
  813.     void read ()
  814.     {
  815.         end_marker = (*stream) ? true : false;
  816.         if (end_marker) *stream >> value;
  817.         end_marker = (*stream) ? true : false;
  818.     }
  819. public:
  820.     typedef T value_type;
  821.     typedef charT char_type;
  822.     typedef traits traits_type;
  823.     typedef istream istream_type;
  824.  
  825.     istream_iterator () : stream(&cin), end_marker(false) {}
  826.     istream_iterator (istream& s) : stream(&s) { read(); }
  827.     istream_iterator ( const istream_iterator<T,charT,traits,Distance>& x )
  828.     :stream(x.stream) , value(x.value) , end_marker(x.end_marker)
  829.     { }
  830.     const T& operator* () const { return value; }
  831.     #ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN
  832.     const T* operator->() const { return &value; }
  833.     #endif
  834.     istream_iterator<T, charT,traits,Distance>& operator++ ()
  835.     { 
  836.         read(); return *this;
  837.     }
  838.     istream_iterator<T, charT,traits,Distance> operator++ (int)
  839.     {
  840.         istream_iterator<T, charT,traits,Distance> tmp = *this; 
  841.         read(); 
  842.         return tmp;
  843.     }
  844. };
  845.  
  846. template <class T, class charT, class traits, class Distance>
  847. inline bool operator== (const istream_iterator<T, charT,traits,Distance>& x,
  848.                         const istream_iterator<T, charT,traits,Distance>& y)
  849. {
  850.     return x.stream == y.stream && x.end_marker == y.end_marker ||
  851.            x.end_marker == false && y.end_marker == false;
  852. }
  853.  
  854. #if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
  855. template <class T, class charT, class traits, class Distance>
  856. inline bool operator!= (const istream_iterator<T, charT,traits,Distance>& x,
  857.                         const istream_iterator<T, charT,traits,Distance>& y)
  858. {
  859.     return !(x == y);
  860. }
  861. #endif
  862.  
  863. #ifndef _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES
  864. template <class T, class charT, 
  865.           class traits = char_traits<charT> >
  866. #else
  867. template <class T, class charT, class traits>
  868. #endif
  869. class ostream_iterator : public output_iterator
  870. {
  871. protected:
  872.  
  873.     ostream* stream;
  874.     const char*    str;
  875.  
  876. public:
  877.     typedef T value_type;
  878.     typedef charT char_type;
  879.     typedef traits traits_type;
  880.     typedef ostream istream_type;
  881.  
  882.     ostream_iterator (ostream& s) : stream(&s), str(0) { ; }
  883.     ostream_iterator (ostream& s,const char* c) 
  884.       : stream(&s), str((char *)c)  { ; }
  885.     ostream_iterator ( const ostream_iterator<T,charT,traits>& x )
  886.       :stream(x.stream) , str(x.str)
  887.     { ; }
  888.     ostream_iterator<T,charT,traits>& operator= (const T& value)
  889.     { 
  890.         *stream << value;
  891.         if (str) *stream << str;
  892.         return *this;
  893.     }
  894.     ostream_iterator<T,charT,traits>& operator*  ()    { return *this; }
  895.     ostream_iterator<T,charT,traits>& operator++ ()    { return *this; } 
  896.     ostream_iterator<T,charT,traits>& operator++ (int) { return *this; }
  897. };
  898.  
  899.  
  900. #endif /* _RW_STD_IOSTREAM */
  901.  
  902.  
  903. #ifndef _RWSTD_NO_NAMESPACE
  904. }
  905. #endif
  906.  
  907. #ifdef _RWSTD_NO_TEMPLATE_REPOSITORY
  908. #include <iterator.cc>
  909. #endif
  910.  
  911. #pragma option pop
  912. #endif /* __STD_ITERATOR__ */
  913.